home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / 3DDEMO.ZIP / 3D / SOURCE / INPUT.CPP < prev    next >
C/C++ Source or Header  |  1996-07-16  |  26KB  |  1,199 lines
  1. #include "input.hpp"
  2. #include <dos.h>
  3.  
  4. // Copyright (c) 1996 by Kerrigan Burgess, all rights reserved.
  5.  
  6. void (_interrupt _far *Old_Isr)(void);
  7. void _interrupt _far New_Key_Int(void);
  8.  
  9. short raw_key;                   // scan codes for keyboard.
  10. short key_table[128];
  11. int keys_active=0;
  12.  
  13. void InitKeyBoard(void)
  14. {
  15.    Old_Isr=_dos_getvect(KEYBOARD_INT);   // save BIOS keyboard interrupt
  16.    _dos_setvect(KEYBOARD_INT,New_Key_Int);   // install new int 9h handler
  17.  
  18.    memset(key_table,0,128);         
  19. }
  20.  
  21. void RestoreKeyBoard(void)
  22. {
  23.    _dos_setvect(KEYBOARD_INT,Old_Isr);   // restore BIOS keyboard interrupt
  24. }
  25.     
  26. #pragma aux GetKeyCodes=\
  27.       "sti"\
  28.       "in al,0x60"\
  29.       "xor ah,ah"\
  30.       "mov raw_key,ax"\
  31.       "in al,0x61"\
  32.       "or al,82h"\
  33.       "out 0x61,al"\
  34.       "and al,7fh"\
  35.       "out 0x61,al"\
  36.       "mov al,20h"\
  37.       "out 0x20,al"\
  38.       ;
  39.       
  40. void _interrupt _far New_Key_Int(void)
  41. {
  42.       GetKeyCodes();
  43.     
  44.       switch(raw_key)
  45.     {
  46.        case MAKE_ESC:
  47.           key_table[SCAN_ESC]=1;
  48.               keys_active++;
  49.        break;
  50.        case MAKE_1:
  51.           key_table[SCAN_1]=1;
  52.               keys_active++;
  53.        break;
  54.        case MAKE_2:
  55.           key_table[SCAN_2]=1;
  56.               keys_active++;
  57.        break;
  58.        case MAKE_3:
  59.           key_table[SCAN_3]=1;
  60.               keys_active++;
  61.        break;
  62.        case MAKE_4:
  63.           key_table[SCAN_4]=1;
  64.               keys_active++;
  65.        break;
  66.        case MAKE_5:
  67.           key_table[SCAN_5]=1;
  68.               keys_active++;
  69.        break;
  70.        case MAKE_6:
  71.           key_table[SCAN_6]=1;
  72.               keys_active++;
  73.        break;
  74.        case MAKE_7:
  75.           key_table[SCAN_7]=1;
  76.               keys_active++;
  77.        break;
  78.        case MAKE_8:
  79.           key_table[SCAN_8]=1;
  80.               keys_active++;
  81.        break;
  82.        case MAKE_9:
  83.           key_table[SCAN_9]=1;
  84.               keys_active++;
  85.        break;
  86.        case MAKE_0:
  87.           key_table[SCAN_0]=1;
  88.               keys_active++;
  89.        break;
  90.        case MAKE_MINUS:
  91.           key_table[SCAN_MINUS]=1;
  92.               keys_active++;
  93.        break;
  94.        case MAKE_EQUAL:
  95.           key_table[SCAN_EQUAL]=1;
  96.               keys_active++;
  97.        break;
  98.        case MAKE_BKSP:
  99.           key_table[SCAN_BKSP]=1;
  100.               keys_active++;
  101.        break; 
  102.        case MAKE_TAB:
  103.           key_table[SCAN_TAB]=1;
  104.               keys_active++;
  105.        break;
  106.        case MAKE_Q:
  107.           key_table[SCAN_Q]=1;
  108.               keys_active++;
  109.        break;
  110.        case MAKE_W:
  111.           key_table[SCAN_W]=1;
  112.               keys_active++;
  113.        break;
  114.        case MAKE_E:
  115.           key_table[SCAN_E]=1;
  116.               keys_active++;
  117.        break;
  118.        case MAKE_R:
  119.           key_table[SCAN_R]=1;
  120.               keys_active++;
  121.        break;
  122.        case MAKE_T:
  123.           key_table[SCAN_T]=1;
  124.               keys_active++;
  125.        break;
  126.        case MAKE_Y:
  127.           key_table[SCAN_Y]=1;
  128.               keys_active++;
  129.        break;
  130.        case MAKE_U:
  131.           key_table[SCAN_U]=1;
  132.               keys_active++;
  133.        break;
  134.        case MAKE_I:
  135.           key_table[SCAN_I]=1;
  136.               keys_active++;
  137.        break;
  138.        case MAKE_O:
  139.           key_table[SCAN_O]=1;
  140.               keys_active++;
  141.        break;
  142.        case MAKE_P:
  143.           key_table[SCAN_P]=1;
  144.               keys_active++;
  145.        break;
  146.        case MAKE_LSB:
  147.           key_table[SCAN_LSB]=1;
  148.               keys_active++;
  149.        break;
  150.        case MAKE_RSB:
  151.           key_table[SCAN_RSB]=1;
  152.               keys_active++;
  153.        break;
  154.        case MAKE_ENTER:
  155.           key_table[SCAN_ENTER]=1;
  156.               keys_active++;
  157.        break;
  158.        case MAKE_CTRL:
  159.           key_table[SCAN_CTRL]=1;
  160.               keys_active++;
  161.        break;
  162.        case MAKE_A:
  163.           key_table[SCAN_A]=1;
  164.               keys_active++;
  165.        break;
  166.        case MAKE_S:
  167.           key_table[SCAN_S]=1;
  168.               keys_active++;
  169.        break;
  170.        case MAKE_D:
  171.           key_table[SCAN_D]=1;
  172.               keys_active++;
  173.        break;
  174.        case MAKE_F:
  175.           key_table[SCAN_F]=1;
  176.               keys_active++;
  177.        break;
  178.        case MAKE_G:
  179.           key_table[SCAN_G]=1;
  180.               keys_active++;
  181.        break;
  182.        case MAKE_H:
  183.           key_table[SCAN_H]=1;
  184.               keys_active++;
  185.        break;
  186.        case MAKE_J:
  187.           key_table[SCAN_J]=1;
  188.               keys_active++;
  189.        break;
  190.        case MAKE_K:
  191.           key_table[SCAN_K]=1;
  192.               keys_active++;
  193.        break;
  194.        case MAKE_L:
  195.           key_table[SCAN_L]=1;
  196.               keys_active++;
  197.        break;
  198.        case MAKE_SEMICOLON:
  199.           key_table[SCAN_SEMICOLON]=1;
  200.               keys_active++;
  201.        break;
  202.        case MAKE_APOS:
  203.           key_table[SCAN_APOS]=1;
  204.               keys_active++;
  205.        break;
  206.        case MAKE_TILDE:
  207.           key_table[SCAN_TILDE]=1;
  208.               keys_active++;
  209.        break;
  210.        case MAKE_LEFTSHFT:
  211.           key_table[SCAN_LEFTSHFT]=1;
  212.               keys_active++;
  213.        break;
  214.        case MAKE_BACKSLASH:
  215.           key_table[SCAN_BACKSLASH]=1;
  216.               keys_active++;
  217.        break;
  218.        case MAKE_Z:
  219.           key_table[SCAN_Z]=1;
  220.               keys_active++;
  221.        break;
  222.        case MAKE_X:
  223.           key_table[SCAN_X]=1;
  224.               keys_active++;
  225.        break;
  226.        case MAKE_C:
  227.           key_table[SCAN_C]=1;
  228.               keys_active++;
  229.        break;
  230.        case MAKE_V:
  231.           key_table[SCAN_V]=1;
  232.               keys_active++;
  233.        break;
  234.        case MAKE_B:
  235.           key_table[SCAN_B]=1;
  236.               keys_active++;
  237.        break;
  238.        case MAKE_N:
  239.           key_table[SCAN_N]=1;
  240.               keys_active++;
  241.        break;
  242.        case MAKE_M:
  243.           key_table[SCAN_M]=1;
  244.               keys_active++;
  245.        break;
  246.        case MAKE_COMMA:
  247.           key_table[SCAN_COMMA]=1;
  248.               keys_active++;
  249.        break;
  250.        case MAKE_PERIOD:
  251.           key_table[SCAN_PERIOD]=1;
  252.               keys_active++;
  253.        break;
  254.        case MAKE_SLASH:
  255.           key_table[SCAN_SLASH]=1;
  256.               keys_active++;
  257.        break;
  258.        case MAKE_RIGHTSHFT:
  259.           key_table[SCAN_RIGHTSHFT]=1;
  260.               keys_active++;
  261.        break;
  262.        case MAKE_PRINTSCRN:
  263.           key_table[SCAN_PRINTSCRN]=1;
  264.               keys_active++;
  265.        break;
  266.        case MAKE_ALT:
  267.           key_table[SCAN_ALT]=1;
  268.               keys_active++;
  269.        break;
  270.        case MAKE_SPACE:
  271.           key_table[SCAN_SPACE]=1;
  272.               keys_active++;
  273.        break;
  274.        case MAKE_CAPLOCK:
  275.           key_table[SCAN_CAPLOCK]=1;
  276.               keys_active++;
  277.        break;
  278.        case MAKE_F1:
  279.           key_table[SCAN_F1]=1;
  280.               keys_active++;
  281.        break;
  282.        case MAKE_F2:
  283.           key_table[SCAN_F2]=1;
  284.               keys_active++;
  285.        break;
  286.        case MAKE_F3:
  287.           key_table[SCAN_F3]=1;
  288.               keys_active++;
  289.        break;
  290.        case MAKE_F4:
  291.           key_table[SCAN_F4]=1;
  292.               keys_active++;
  293.        break;
  294.        case MAKE_F5:
  295.           key_table[SCAN_F5]=1;
  296.               keys_active++;
  297.        break;
  298.        case MAKE_F6:
  299.           key_table[SCAN_F6]=1;
  300.               keys_active++;
  301.        break;
  302.        case MAKE_F7:
  303.           key_table[SCAN_F7]=1;
  304.               keys_active++;
  305.        break;
  306.        case MAKE_F8:
  307.           key_table[SCAN_F8]=1;
  308.               keys_active++;
  309.        break;
  310.        case MAKE_F9:
  311.           key_table[SCAN_F9]=1;
  312.               keys_active++;
  313.        break;
  314.        case MAKE_F10:
  315.           key_table[SCAN_F10]=1;
  316.               keys_active++;
  317.        break;
  318.        case MAKE_NUMLOCK:
  319.           key_table[SCAN_NUMLOCK]=1;
  320.               keys_active++;
  321.        break;
  322.        case MAKE_SCROLLOCK:
  323.           key_table[SCAN_SCROLLOCK]=1;
  324.               keys_active++;
  325.        break;
  326.        case MAKE_HOME:
  327.           key_table[SCAN_HOME]=1;
  328.               keys_active++;
  329.        break;
  330.        case MAKE_UP:
  331.           key_table[SCAN_UP]=1; 
  332.               keys_active++;
  333.        break;
  334.        case MAKE_PGUP:
  335.           key_table[SCAN_PGUP]=1;
  336.               keys_active++;
  337.        break;
  338.        case MAKE_KEYPADMINUS:
  339.           key_table[SCAN_KEYPADMINUS]=1;
  340.               keys_active++;
  341.        break;
  342.        case MAKE_LEFT:
  343.           key_table[SCAN_LEFT]=1;
  344.               keys_active++;
  345.        break;
  346.        case MAKE_CENTER:
  347.           key_table[SCAN_CENTER]=1;
  348.               keys_active++;
  349.        break;
  350.        case MAKE_RIGHT:
  351.           key_table[SCAN_RIGHT]=1;
  352.               keys_active++;
  353.        break;
  354.        case MAKE_KEYPADPLUS:
  355.           key_table[SCAN_KEYPADPLUS]=1;
  356.               keys_active++;
  357.        break;
  358.        case MAKE_END:
  359.           key_table[SCAN_END]=1;
  360.               keys_active++;
  361.        break;
  362.        case MAKE_DOWN:
  363.           key_table[SCAN_DOWN]=1;
  364.               keys_active++;
  365.        break;
  366.        case MAKE_PGDOWN:
  367.           key_table[SCAN_PGDOWN]=1;
  368.               keys_active++;
  369.        break;
  370.        case MAKE_INSERT:
  371.           key_table[SCAN_INSERT]=1;
  372.               keys_active++;
  373.        break;
  374.        case MAKE_DELETE:
  375.           key_table[SCAN_DELETE]=1;
  376.               keys_active++;
  377.        break;
  378.        case MAKE_F11:
  379.           key_table[SCAN_F11]=1;
  380.               keys_active++;
  381.        break;
  382.        case MAKE_F12:
  383.           key_table[SCAN_F12]=1;
  384.               keys_active++;
  385.        break;
  386.  
  387.        case BREAK_ESC:
  388.           key_table[SCAN_ESC]=0;
  389.               keys_active--;
  390.        break;
  391.        case BREAK_1:
  392.           key_table[SCAN_1]=0;
  393.               keys_active--;
  394.        break;
  395.        case BREAK_2:
  396.           key_table[SCAN_2]=0;
  397.               keys_active--;
  398.        break;
  399.        case BREAK_3:
  400.           key_table[SCAN_3]=0;
  401.               keys_active--;
  402.        break;
  403.        case BREAK_4:
  404.           key_table[SCAN_4]=0;
  405.               keys_active--;
  406.        break;
  407.        case BREAK_5:
  408.           key_table[SCAN_5]=0;
  409.               keys_active--;
  410.        break;
  411.        case BREAK_6:
  412.           key_table[SCAN_6]=0;
  413.               keys_active--;
  414.        break;
  415.        case BREAK_7:
  416.           key_table[SCAN_7]=0;
  417.               keys_active--;
  418.        break;
  419.        case BREAK_8:
  420.           key_table[SCAN_8]=0;
  421.               keys_active--;
  422.        break;
  423.        case BREAK_9:
  424.           key_table[SCAN_9]=0;
  425.               keys_active--;
  426.        break;
  427.        case BREAK_0:
  428.           key_table[SCAN_0]=0;
  429.               keys_active--;
  430.        break;
  431.        case BREAK_MINUS:
  432.           key_table[SCAN_MINUS]=0;
  433.               keys_active--;
  434.        break;
  435.        case BREAK_EQUAL:
  436.           key_table[SCAN_EQUAL]=0;
  437.               keys_active--;
  438.        break;
  439.        case BREAK_BKSP:
  440.           key_table[SCAN_BKSP]=0;
  441.               keys_active--;
  442.        break;
  443.        case BREAK_TAB:
  444.           key_table[SCAN_TAB]=0;
  445.               keys_active--;
  446.        break;
  447.        case BREAK_Q:
  448.           key_table[SCAN_Q]=0;
  449.               keys_active--;
  450.        break;
  451.        case BREAK_W:
  452.           key_table[SCAN_W]=0;
  453.               keys_active--;
  454.        break;
  455.        case BREAK_E:
  456.           key_table[SCAN_E]=0;
  457.               keys_active--;
  458.        break;
  459.        case BREAK_R:
  460.           key_table[SCAN_R]=0;
  461.               keys_active--;
  462.        break;
  463.        case BREAK_T:
  464.           key_table[SCAN_T]=0;
  465.               keys_active--;
  466.        break;
  467.        case BREAK_Y:
  468.           key_table[SCAN_Y]=0;
  469.               keys_active--;
  470.        break;
  471.        case BREAK_U:
  472.           key_table[SCAN_U]=0;
  473.               keys_active--;
  474.        break;
  475.        case BREAK_I:
  476.           key_table[SCAN_I]=0;
  477.               keys_active--;
  478.        break;
  479.        case BREAK_O:
  480.           key_table[SCAN_O]=0;
  481.               keys_active--;
  482.        break;
  483.        case BREAK_P:
  484.           key_table[SCAN_P]=0;
  485.               keys_active--;
  486.        break;
  487.        case BREAK_LSB:
  488.           key_table[SCAN_LSB]=0;
  489.               keys_active--;
  490.        break;
  491.        case BREAK_RSB:
  492.           key_table[SCAN_RSB]=0;
  493.               keys_active--;
  494.        break;
  495.        case BREAK_ENTER:
  496.           key_table[SCAN_ENTER]=0;
  497.               keys_active--;
  498.        break;
  499.        case BREAK_CTRL:
  500.           key_table[SCAN_CTRL]=0;
  501.               keys_active--;
  502.        break;
  503.        case BREAK_A:
  504.           key_table[SCAN_A]=0;
  505.               keys_active--;
  506.        break;
  507.        case BREAK_S:
  508.           key_table[SCAN_S]=0;
  509.               keys_active--;
  510.        break;
  511.        case BREAK_D:
  512.           key_table[SCAN_D]=0;
  513.               keys_active--;
  514.        break;
  515.        case BREAK_F:
  516.           key_table[SCAN_F]=0;
  517.               keys_active--;
  518.        break;
  519.        case BREAK_G:
  520.           key_table[SCAN_G]=0;
  521.               keys_active--;
  522.        break;
  523.        case BREAK_H:
  524.           key_table[SCAN_H]=0;
  525.               keys_active--;
  526.        break;
  527.        case BREAK_J:
  528.           key_table[SCAN_J]=0;
  529.               keys_active--;
  530.        break;
  531.        case BREAK_K:
  532.           key_table[SCAN_K]=0;
  533.               keys_active--;
  534.        break;
  535.        case BREAK_L:
  536.           key_table[SCAN_L]=0;
  537.               keys_active--;
  538.        break;
  539.        case BREAK_SEMICOLON:
  540.           key_table[SCAN_SEMICOLON]=0;
  541.               keys_active--;
  542.        break;
  543.        case BREAK_APOS:
  544.           key_table[SCAN_APOS]=0;
  545.               keys_active--;
  546.        break;
  547.        case BREAK_TILDE:
  548.           key_table[SCAN_TILDE]=0;
  549.               keys_active--;
  550.        break;
  551.        case BREAK_LEFTSHFT:
  552.           key_table[SCAN_LEFTSHFT]=0;
  553.               keys_active--;
  554.        break;
  555.        case BREAK_BACKSLASH:
  556.           key_table[SCAN_BACKSLASH]=0;
  557.               keys_active--;
  558.        break;
  559.        case BREAK_Z:
  560.           key_table[SCAN_Z]=0;
  561.               keys_active--;
  562.        break;
  563.        case BREAK_X:
  564.           key_table[SCAN_X]=0;
  565.               keys_active--;
  566.        break;
  567.        case BREAK_C:
  568.           key_table[SCAN_C]=0;
  569.               keys_active--;
  570.        break;
  571.        case BREAK_V:
  572.           key_table[SCAN_V]=0;
  573.               keys_active--;
  574.        break;
  575.        case BREAK_B:
  576.           key_table[SCAN_B]=0;
  577.               keys_active--;
  578.        break;
  579.        case BREAK_N:
  580.           key_table[SCAN_N]=0;
  581.               keys_active--;
  582.        break;
  583.        case BREAK_M:
  584.           key_table[SCAN_M]=0;
  585.               keys_active--;
  586.        break;
  587.        case BREAK_COMMA:
  588.           key_table[SCAN_COMMA]=0;
  589.               keys_active--;
  590.        break;
  591.        case BREAK_PERIOD:
  592.           key_table[SCAN_PERIOD]=0;
  593.               keys_active--;
  594.        break;
  595.        case BREAK_SLASH:
  596.           key_table[SCAN_SLASH]=0;
  597.               keys_active--;
  598.        break;
  599.        case BREAK_RIGHTSHFT:
  600.           key_table[SCAN_RIGHTSHFT]=0;
  601.               keys_active--;
  602.        break;
  603.        case BREAK_PRINTSCRN:
  604.           key_table[SCAN_PRINTSCRN]=0;
  605.               keys_active--;
  606.        break;
  607.        case BREAK_ALT:
  608.           key_table[SCAN_ALT]=0;
  609.               keys_active--;
  610.        break;
  611.        case BREAK_SPACE:
  612.           key_table[SCAN_SPACE]=0;
  613.               keys_active--;
  614.        break;
  615.        case BREAK_CAPLOCK:
  616.           key_table[SCAN_CAPLOCK]=0;
  617.               keys_active--;
  618.        break;
  619.        case BREAK_F1:
  620.           key_table[SCAN_F1]=0;
  621.               keys_active--;
  622.        break;
  623.        case BREAK_F2:
  624.           key_table[SCAN_F2]=0;
  625.               keys_active--;
  626.        break;
  627.        case BREAK_F3:
  628.           key_table[SCAN_F3]=0;
  629.               keys_active--;
  630.        break;
  631.        case BREAK_F4:
  632.           key_table[SCAN_F4]=0;
  633.               keys_active--;
  634.        break;
  635.        case BREAK_F5:
  636.           key_table[SCAN_F5]=0;
  637.               keys_active--;
  638.        break;
  639.        case BREAK_F6:
  640.           key_table[SCAN_F6]=0;
  641.               keys_active--;
  642.        break;
  643.        case BREAK_F7:
  644.           key_table[SCAN_F7]=0;
  645.               keys_active--;
  646.        break;
  647.        case BREAK_F8:
  648.           key_table[SCAN_F8]=0;
  649.               keys_active--;
  650.        break;
  651.        case BREAK_F9:
  652.           key_table[SCAN_F9]=0;
  653.               keys_active--;
  654.        break;
  655.        case BREAK_F10:
  656.           key_table[SCAN_F10]=0;
  657.               keys_active--;
  658.        break;
  659.        case BREAK_NUMLOCK:
  660.           key_table[SCAN_NUMLOCK]=0;
  661.               keys_active--;
  662.        break;
  663.        case BREAK_SCROLLOCK:
  664.           key_table[SCAN_SCROLLOCK]=0;
  665.               keys_active--;
  666.        break;
  667.        case BREAK_HOME:
  668.           key_table[SCAN_HOME]=0;
  669.               keys_active--;
  670.        break;
  671.        case BREAK_UP:
  672.           key_table[SCAN_UP]=0; 
  673.               keys_active--;
  674.        break;
  675.        case BREAK_PGUP:
  676.           key_table[SCAN_PGUP]=0;
  677.               keys_active--;
  678.        break;
  679.        case BREAK_KEYPADMINUS:
  680.           key_table[SCAN_KEYPADMINUS]=0;
  681.               keys_active--;
  682.        break;
  683.        case BREAK_LEFT:
  684.           key_table[SCAN_LEFT]=0;
  685.               keys_active--;
  686.        break;
  687.        case BREAK_CENTER:
  688.           key_table[SCAN_CENTER]=0;
  689.               keys_active--;
  690.        break;
  691.        case BREAK_RIGHT:
  692.           key_table[SCAN_RIGHT]=0;
  693.               keys_active--;
  694.        break;
  695.        case BREAK_KEYPADPLUS:
  696.           key_table[SCAN_KEYPADPLUS]=0;
  697.               keys_active--;
  698.        break;
  699.        case BREAK_END:
  700.           key_table[SCAN_END]=0;
  701.               keys_active--;
  702.        break;
  703.        case BREAK_DOWN:
  704.           key_table[SCAN_DOWN]=0;
  705.               keys_active--;
  706.        break;
  707.        case BREAK_PGDOWN:
  708.           key_table[SCAN_PGDOWN]=0;
  709.               keys_active--;
  710.        break;
  711.        case BREAK_INSERT:
  712.           key_table[SCAN_INSERT]=0;
  713.               keys_active--;
  714.        break;
  715.        case BREAK_DELETE:
  716.           key_table[SCAN_DELETE]=0;
  717.               keys_active--;
  718.        break;
  719.        case BREAK_F11:
  720.           key_table[SCAN_F11]=0;
  721.               keys_active--;
  722.        break;
  723.        case BREAK_F12:
  724.           key_table[SCAN_F12]=0;
  725.               keys_active--;
  726.        break;
  727.        default:
  728.        break;
  729.     }
  730. }
  731.  
  732. KEYBOARDCLASS::KEYBOARDCLASS(void)
  733. {
  734.   InitKeyBoard();
  735. }
  736.  
  737. KEYBOARDCLASS::~KEYBOARDCLASS(void)
  738. {
  739.   RestoreKeyBoard();
  740. }
  741.  
  742. void KEYBOARDCLASS::ClearKeys(void)
  743. {
  744.   memset(key_table,0,128);       // To clear all pending key presses.
  745.   keys_active=0;
  746. }
  747.  
  748. int KEYBOARDCLASS::Is_Key(const short key)
  749. {
  750.   int result;
  751.  
  752.    switch (key)
  753.    {
  754.       case SCAN_ANY:
  755.         if (keys_active)
  756.           result = TRUE;
  757.         else
  758.           result = FALSE;
  759.       break;
  760.       case SCAN_ESC:
  761.     if (key_table[SCAN_ESC])
  762.           result = TRUE;
  763.     else
  764.           result = FALSE;
  765.       break;
  766.       case SCAN_F1:
  767.     if (key_table[SCAN_F1])
  768.           result = TRUE;
  769.     else
  770.           result = FALSE;
  771.       break;
  772.       case SCAN_F2:
  773.     if (key_table[SCAN_F2])
  774.           result = TRUE;
  775.     else
  776.           result = FALSE;
  777.       break;
  778.       case SCAN_F3:
  779.     if (key_table[SCAN_F3])
  780.           result = TRUE;
  781.     else
  782.           result = FALSE;
  783.       break;
  784.       case SCAN_F4:
  785.     if (key_table[SCAN_F4])
  786.           result = TRUE;
  787.     else
  788.           result = FALSE;
  789.       break;
  790.       case SCAN_F5:
  791.     if (key_table[SCAN_F5])
  792.           result = TRUE;
  793.     else
  794.           result = FALSE;
  795.       break;
  796.       case SCAN_F6:
  797.     if (key_table[SCAN_F6])
  798.           result = TRUE;
  799.     else
  800.           result = FALSE;
  801.       break;
  802.       case SCAN_F7:
  803.     if (key_table[SCAN_F7])
  804.           result = TRUE;
  805.     else
  806.           result = FALSE;
  807.       break;
  808.       case SCAN_F8:
  809.     if (key_table[SCAN_F8])
  810.           result = TRUE;
  811.     else
  812.           result = FALSE;
  813.        break;
  814.       case SCAN_F9:
  815.     if (key_table[SCAN_F9])
  816.           result = TRUE;
  817.     else
  818.           result = FALSE;
  819.       break;
  820.       case SCAN_F10:
  821.     if (key_table[SCAN_F10])
  822.           result = TRUE;
  823.     else
  824.           result = FALSE;
  825.       break;
  826.       case SCAN_F11:
  827.     if (key_table[SCAN_F11])
  828.           result = TRUE;
  829.     else
  830.           result = FALSE;
  831.       break;
  832.       case SCAN_F12:
  833.     if (key_table[SCAN_F12])
  834.           result = TRUE;
  835.     else
  836.           result = FALSE;
  837.       break;
  838.       case SCAN_1:
  839.     if (key_table[SCAN_1])
  840.           result = TRUE;
  841.     else
  842.           result = FALSE;
  843.       break;
  844.       case SCAN_2:
  845.      if (key_table[SCAN_2])
  846.           result = TRUE;
  847.     else
  848.           result = FALSE;
  849.       break;
  850.       case SCAN_3:
  851.     if (key_table[SCAN_3])
  852.           result = TRUE;
  853.     else
  854.           result = FALSE;
  855.       break;
  856.       case SCAN_4:
  857.     if (key_table[SCAN_4])
  858.           result = TRUE;
  859.     else
  860.           result = FALSE;
  861.       break;
  862.       case SCAN_5:
  863.     if (key_table[SCAN_5])
  864.           result = TRUE;
  865.     else
  866.           result = FALSE;
  867.       break;
  868.       case SCAN_6:
  869.     if (key_table[SCAN_6])
  870.           result = TRUE;
  871.     else
  872.           result = FALSE;
  873.       break;
  874.       case SCAN_7:
  875.     if (key_table[SCAN_7])
  876.           result = TRUE;
  877.     else
  878.           result = FALSE;
  879.       break;
  880.       case SCAN_8:
  881.     if (key_table[SCAN_8])
  882.           result = TRUE;
  883.     else
  884.           result = FALSE;
  885.       break;
  886.       case SCAN_9:
  887.     if (key_table[SCAN_9])
  888.           result = TRUE;
  889.     else
  890.           result = FALSE;
  891.       break;
  892.       case SCAN_0:
  893.     if (key_table[SCAN_0])
  894.           result = TRUE;
  895.     else
  896.           result = FALSE;
  897.       break;
  898.       case SCAN_MINUS:
  899.      if (key_table[SCAN_MINUS])
  900.           result = TRUE;
  901.     else
  902.           result = FALSE;
  903.       break;
  904.       case SCAN_EQUAL:
  905.      if (key_table[SCAN_EQUAL])
  906.           result = TRUE;
  907.     else
  908.           result = FALSE;
  909.       break;
  910.       case SCAN_BKSP:
  911.     if (key_table[SCAN_BKSP])
  912.           result = TRUE;
  913.     else
  914.           result = FALSE;
  915.       break;
  916.       case SCAN_Q:
  917.     if (key_table[SCAN_Q])
  918.           result = TRUE;
  919.     else
  920.           result = FALSE;
  921.       break;
  922.       case SCAN_W:
  923.     if (key_table[SCAN_W])
  924.           result = TRUE;
  925.     else
  926.           result = FALSE;
  927.       break;
  928.       case SCAN_E:
  929.     if (key_table[SCAN_E])
  930.           result = TRUE;
  931.     else
  932.           result = FALSE;
  933.       break;
  934.       case SCAN_R:
  935.     if (key_table[SCAN_R])
  936.           result = TRUE;
  937.     else
  938.           result = FALSE;
  939.       break;
  940.       case SCAN_T:
  941.     if (key_table[SCAN_T])
  942.           result = TRUE;
  943.     else
  944.           result = FALSE;
  945.       break;
  946.       case SCAN_Y:
  947.     if (key_table[SCAN_Y])
  948.           result = TRUE;
  949.     else
  950.           result = FALSE;
  951.       break;
  952.       case SCAN_U:
  953.     if (key_table[SCAN_U])
  954.           result = TRUE;
  955.     else
  956.           result = FALSE;
  957.       break;
  958.       case SCAN_I:
  959.     if (key_table[SCAN_I])
  960.           result = TRUE;
  961.     else
  962.           result = FALSE;
  963.       break;
  964.       case SCAN_O:
  965.     if (key_table[SCAN_O])
  966.           result = TRUE;
  967.     else
  968.           result = FALSE;
  969.       break;
  970.       case SCAN_P:
  971.     if (key_table[SCAN_P])
  972.           result = TRUE;
  973.     else
  974.           result = FALSE;
  975.       break;
  976.       case SCAN_LSB:
  977.     if (key_table[SCAN_LSB])
  978.           result = TRUE;
  979.     else
  980.           result = FALSE;
  981.       break;
  982.       case SCAN_RSB:
  983.     if (key_table[SCAN_RSB])
  984.           result = TRUE;
  985.     else
  986.           result = FALSE;
  987.       break;
  988.       case SCAN_ENTER:
  989.     if (key_table[SCAN_ENTER])
  990.           result = TRUE;
  991.     else
  992.           result = FALSE;
  993.       break;
  994.       case SCAN_A:
  995.     if (key_table[SCAN_A])
  996.           result = TRUE;
  997.     else
  998.           result = FALSE;
  999.       break;
  1000.       case SCAN_S:
  1001.     if (key_table[SCAN_S])
  1002.           result = TRUE;
  1003.     else
  1004.           result = FALSE;
  1005.       break;
  1006.       case SCAN_D:
  1007.     if (key_table[SCAN_D])
  1008.            result = TRUE;
  1009.     else
  1010.           result = FALSE;
  1011.       break;
  1012.       case SCAN_F:
  1013.     if (key_table[SCAN_F])
  1014.           result = TRUE;
  1015.     else
  1016.           result = FALSE;
  1017.       break;
  1018.       case SCAN_G:
  1019.     if (key_table[SCAN_G])
  1020.           result = TRUE;
  1021.     else
  1022.           result = FALSE;
  1023.       break;
  1024.       case SCAN_H:
  1025.     if (key_table[SCAN_H])
  1026.           result = TRUE;
  1027.     else
  1028.           result = FALSE;
  1029.       break;
  1030.       case SCAN_J:
  1031.     if (key_table[SCAN_J])
  1032.           result = TRUE;
  1033.     else
  1034.           result = FALSE;
  1035.       break;
  1036.       case SCAN_K:
  1037.     if (key_table[SCAN_K])
  1038.           result = TRUE;
  1039.     else
  1040.           result = FALSE;
  1041.       break;
  1042.       case SCAN_L:
  1043.     if (key_table[SCAN_L])
  1044.           result = TRUE;
  1045.     else
  1046.           result = FALSE;
  1047.       break;
  1048.       case SCAN_SEMICOLON:
  1049.     if (key_table[SCAN_SEMICOLON])
  1050.           result = TRUE;
  1051.     else
  1052.           result = FALSE;
  1053.       break;
  1054.       case SCAN_APOS:
  1055.     if (key_table[SCAN_APOS])
  1056.           result = TRUE;
  1057.     else
  1058.           result = FALSE;
  1059.       break;
  1060.       case SCAN_Z:
  1061.     if (key_table[SCAN_Z])
  1062.           result = TRUE;
  1063.     else
  1064.           result = FALSE;
  1065.       break;
  1066.       case SCAN_X:
  1067.     if (key_table[SCAN_X])
  1068.           result = TRUE;
  1069.     else
  1070.           result = FALSE;
  1071.       break;
  1072.       case SCAN_C:
  1073.     if (key_table[SCAN_C])
  1074.           result = TRUE;
  1075.     else
  1076.           result = FALSE;
  1077.       break;
  1078.       case SCAN_V:
  1079.     if (key_table[SCAN_V])
  1080.           result = TRUE;
  1081.     else
  1082.           result = FALSE;
  1083.       break;
  1084.       case SCAN_B:
  1085.     if (key_table[SCAN_B])
  1086.           result = TRUE;
  1087.     else
  1088.           result = FALSE;
  1089.       break;
  1090.       case SCAN_N:
  1091.     if (key_table[SCAN_N])
  1092.           result = TRUE;
  1093.     else
  1094.           result = FALSE;
  1095.       break;
  1096.       case SCAN_M:
  1097.     if (key_table[SCAN_M])
  1098.           result = TRUE;
  1099.     else
  1100.           result = FALSE;
  1101.       break;
  1102.       case SCAN_COMMA:
  1103.     if (key_table[SCAN_COMMA])
  1104.           result = TRUE;
  1105.     else
  1106.           result = FALSE;
  1107.       break;
  1108.       case SCAN_PERIOD:
  1109.     if (key_table[SCAN_PERIOD])
  1110.           result = TRUE;
  1111.     else
  1112.           result = FALSE;
  1113.       break;
  1114.       case SCAN_SLASH:
  1115.     if (key_table[SCAN_SLASH])
  1116.           result = TRUE;
  1117.     else
  1118.           result = FALSE;
  1119.       break;
  1120.       case SCAN_INSERT:
  1121.     if (key_table[SCAN_INSERT])
  1122.           result = TRUE;
  1123.     else
  1124.           result = FALSE;
  1125.       break;
  1126.       case SCAN_DELETE:
  1127.     if (key_table[SCAN_DELETE])
  1128.           result = TRUE;
  1129.     else
  1130.           result = FALSE;
  1131.       break;
  1132.       case SCAN_HOME:
  1133.     if (key_table[SCAN_HOME])
  1134.           result = TRUE;
  1135.     else
  1136.           result = FALSE;
  1137.       break;
  1138.       case SCAN_END:
  1139.     if (key_table[SCAN_END])
  1140.           result = TRUE;
  1141.     else
  1142.           result = FALSE;
  1143.       break;
  1144.       case SCAN_PGUP:
  1145.     if (key_table[SCAN_PGUP])
  1146.           result = TRUE;
  1147.     else
  1148.           result = FALSE;
  1149.       break;
  1150.       case SCAN_PGDOWN:
  1151.     if (key_table[SCAN_PGDOWN])
  1152.           result = TRUE;
  1153.     else
  1154.           result = FALSE;
  1155.       break;
  1156.       case SCAN_RIGHT:
  1157.     if (key_table[SCAN_RIGHT])
  1158.           result = TRUE;
  1159.     else
  1160.           result = FALSE;
  1161.       break;
  1162.       case SCAN_LEFT:
  1163.     if (key_table[SCAN_LEFT])
  1164.           result = TRUE;
  1165.     else
  1166.           result = FALSE;
  1167.       break;
  1168.       case SCAN_UP:
  1169.     if (key_table[SCAN_UP])
  1170.           result = TRUE;
  1171.     else
  1172.           result = FALSE;
  1173.       break;
  1174.       case SCAN_DOWN:
  1175.     if (key_table[SCAN_DOWN])
  1176.           result = TRUE;
  1177.     else
  1178.           result = FALSE;
  1179.       break;
  1180.      
  1181.       default:
  1182.         result = FALSE;
  1183.       break;
  1184.    }
  1185.   return (result);
  1186. }
  1187.    
  1188. INPUTCLASS::INPUTCLASS(void)               // constructor.
  1189. {
  1190.  
  1191. }
  1192.  
  1193.  
  1194. INPUTCLASS::~INPUTCLASS(void)              // destructor.
  1195. {
  1196.  
  1197. }
  1198.  
  1199.